package com.css.upms.biz.controller;

import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.css.common.core.utils.R;
import com.css.lion.optlog.agent.annotation.OptLog;
import com.css.upms.api.dto.DeptDTO;
import com.css.upms.api.dto.DeptTree;
import com.css.upms.api.entity.SysDept;
import com.css.upms.api.vo.TreeUtil;
import com.css.upms.biz.service.SysDeptService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.web.bind.annotation.*;

import java.util.List;
import java.util.stream.Collectors;

/**
 * 部门管理
 *
 * @author hanyx
 * @date 2019-05-03 02:04:56
 */
@RestController
@AllArgsConstructor
@RequestMapping("/dept")
@Api(value = "/dept", tags = {"UPMS-部门管理"})
@Slf4j
public class DeptController {

    private final SysDeptService deptService;

    /**
     * 简单分页查询
     *
     * @param page    分页对象
     * @param deptDTO 部门管理
     * @return
     */
    @ApiOperation(value = "简单分页查询")
    @GetMapping("/page")
    public R<IPage<SysDept>> getDeptPage(Page<SysDept> page, DeptDTO deptDTO) {
        SysDept dept = new SysDept();
        BeanUtils.copyProperties(deptDTO, dept);
        return new R<>(deptService.getSysDeptPage(page, dept));
    }

    /**
     * 返回树形机构集合
     *
     * @return 树形菜单
     */
    @ApiOperation(value = "返回所有树形机构集合 - 树结构")
    @GetMapping(value = "/tree")
    public R listDeptTrees() {
        return new R<>(deptService.listDeptTrees());
    }

    /**
     * 获取给予数据权限的部门树,跨多级数据权限时还需要构建缺失节点,暂不使用
     *
     * @return 树形部门树集合
     */
//    @ApiOperation(value = "获取给予数据权限的部门树 - 树结构")
//    @GetMapping(value = "/dataScope/tree")
    public R listDataScopeTrees() {
        return new R<>(deptService.listDataScopeTrees());
    }


    @ApiOperation(value = "返回树形机构集合 - list结构")
    @GetMapping(value = "/tree/{deptName}")
    public R listDeptTrees(@PathVariable String deptName) {
        if (StringUtils.isBlank(deptName)) {
            return this.listDeptTrees();
        }
        SysDept dept = new SysDept();
        dept.setDeptName(deptName);
        return new R<>(TreeUtil.buildDeptIst(deptService.getSysDeptList(dept)));
    }


    /**
     * 返回当前用户树形机构集合
     *
     * @return 树形菜单
     */
    @ApiOperation(value = "返回当前用户树形机构集合 - 树结构")
    @GetMapping(value = "/user-tree")
    public R listCurrentUserDeptTrees() {
        return new R<>(deptService.listCurrentUserDeptTrees());
    }

    @ApiOperation(value = "返回当前用户树形机构集合 + 上级机构 - 树结构")
    @GetMapping(value = "/user-tree/parent")
    public R listCurrentUserDeptTreesParent() {
        return new R<>(deptService.listCurrentUserDeptTrees(Boolean.TRUE));
    }


    /**
     * 返回指定用户树形机构集合
     *
     * @return 树形菜单
     */
    @ApiOperation(value = "返回指定用户树形机构集合 - 树结构")
    @GetMapping(value = "/user-tree/{userId}")
    public R listDeptTreesByUserId(@PathVariable String userId) {
        if (StringUtils.isBlank(userId)) {
            return R.buildError("用户id不能为空");
        }
        List<DeptTree> result = deptService.listDeptTreesByUserId(userId);
        if (CollectionUtils.isEmpty(result)) {
            return R.buildError("用户不存在");
        }
        return R.buildSuccess(result);
    }

    /**
     * 返回指定角色的部门id集合
     *
     * @param roleId 角色ID
     * @return 机构树集合
     */
    @ApiOperation(value = "返回指定角色的部门id集合 - list结构")
    @GetMapping("/role/{roleId}")
    public R getDeptTreesByRoleId(@PathVariable("roleId") String roleId) {
        if (StringUtils.isBlank(roleId)) {
            return R.buildError("角色id不能为空");
        }
        return R.builder().data(deptService.getDeptByRoleId(roleId)
                .stream()
                .map(SysDept::getDeptId)
                .collect(Collectors.toList())).build();
    }

    /**
     * 返回指定用户数据权限集合 - list结构
     *
     * @param userId 用户ID
     * @return 机构树集合
     */
    @ApiOperation(value = "返回指定用户数据权限集合 - list结构")
    @GetMapping("/user/{userId}")
    public R getDeptTreesByUserId(@PathVariable("userId") String userId) {
        if (StringUtils.isBlank(userId)) {
            return R.buildError("用户id不能为空");
        }
        return R.buildSuccess(deptService.getDeptByUserId(userId)
                .stream()
                .map(SysDept::getDeptId)
                .collect(Collectors.toList()));
    }

    /**
     * 通过id查询单条记录
     *
     * @param deptId
     * @return R
     */
    @ApiOperation(value = "通过id查询单条记录")
    @GetMapping("/{deptId}")
    public R<SysDept> getById(@PathVariable("deptId") String deptId) {
        if (StringUtils.isBlank(deptId)) {
            return R.buildError("部门id不能为空");
        }
        return new R<>(deptService.getById(deptId));
    }

    /**
     * 新增记录
     *
     * @param dept
     * @return R
     */
    @ApiOperation(value = "新增部门管理")
    @OptLog(desc = "部门管理", opt = "新增部门")
    @PostMapping
//  @PreAuthorize("hasAuthority('biz_dept_add')")
    public R save(@RequestBody SysDept dept) {
        return deptService.saveDept(dept);
    }

    /**
     * 修改记录
     *
     * @param dept
     * @return R
     */
    @ApiOperation(value = "修改部门管理")
    @OptLog(desc = "部门管理", opt = "修改部门")
    @PutMapping
//  @PreAuthorize("hasAuthority('biz_dept_edit')")
    public R update(@RequestBody SysDept dept) {
        if (StringUtils.isBlank(dept.getDeptId())) {
            return R.buildError("部门id不能为空");
        }
        if (!deptService.modifyCheck(dept.getDeptId())) {
            return R.buildError("没有修改上级部门权限");
        }
        return deptService.updateDeptById(dept);
    }

    /**
     * 通过id删除一条记录
     *
     * @param deptId
     * @return R
     */
    @ApiOperation(value = "删除部门管理")
    @OptLog(desc = "部门管理", opt = "删除部门")
    @DeleteMapping("/{deptId}")
//  @PreAuthorize("@hasAuthority('biz_dept_del')")
    public R removeById(@PathVariable String deptId) {
        if (StringUtils.isBlank(deptId)) {
            return R.buildError("部门id不能为空");
        }
        return deptService.removeDeptById(deptId);
    }

    /**
     * 判断指定节点是不是当前登录用户的子节点
     *
     * @param deptId
     * @return
     */
    @ApiOperation(value = "判断指定节点是不是当前登录用户的子节点")
    @GetMapping("/child-flag/{deptId}")
    public R modifyCheck(@PathVariable String deptId) {
        if (StringUtils.isBlank(deptId)) {
            return R.buildError("部门id不能为空");
        }
        return R.buildSuccess(deptService.modifyCheck(deptId));
    }

}
